1   /*
2    * Copyright (C) 2012 The Guava Authors
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    * http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package com.google.common.util.concurrent;
18  
19  import static com.google.common.base.Preconditions.checkNotNull;
20  
21  import javax.annotation.Nullable;
22  
23  /**
24   * A settable future that can be set asynchronously via {@link #setFuture}.
25   * A similar effect could be accomplished by adding a listener to the delegate
26   * future that sets a normal settable future after the delegate is complete.
27   * This approach gains us the ability to keep track of whether a delegate has
28   * been set (i.e. so that we can prevent collisions from setting it twice and
29   * can know before the computation is done whether it has been set), as well
30   * as improved cancellation semantics (i.e. if either future is cancelled,
31   * then the other one is too).  This class is thread-safe.
32   *
33   * @param <V> The result type returned by the Future's {@code get} method.
34   *
35   * @author Stephen Hicks
36   */
37  final class AsyncSettableFuture<V> extends ForwardingListenableFuture<V> {
38  
39    /** Creates a new asynchronously-settable future. */
40    public static <V> AsyncSettableFuture<V> create() {
41      return new AsyncSettableFuture<V>();
42    }
43  
44    private final NestedFuture<V> nested = new NestedFuture<V>();
45    private final ListenableFuture<V> dereferenced = Futures.dereference(nested);
46  
47    private AsyncSettableFuture() {}
48  
49    @Override protected ListenableFuture<V> delegate() {
50      return dereferenced;
51    }
52  
53    /**
54     * Sets this future to forward to the given future.  Returns {@code true}
55     * if the future was able to be set (i.e. it hasn't been set already).
56     */
57    public boolean setFuture(ListenableFuture<? extends V> future) {
58      return nested.setFuture(checkNotNull(future));
59    }
60  
61    /**
62     * Convenience method that calls {@link #setFuture} on a {@link
63     * Futures#immediateFuture}.  Returns {@code true} if the future
64     * was able to be set (i.e. it hasn't been set already).
65     */
66    public boolean setValue(@Nullable V value) {
67      return setFuture(Futures.immediateFuture(value));
68    }
69  
70    /**
71     * Convenience method that calls {@link #setFuture} on a {@link
72     * Futures#immediateFailedFuture}.  Returns {@code true} if the
73     * future was able to be set (i.e. it hasn't been set already).
74     */
75    public boolean setException(Throwable exception) {
76      return setFuture(Futures.<V>immediateFailedFuture(exception));
77    }
78  
79    /**
80     * Returns {@code true} if this future has been (possibly asynchronously) set.
81     * Note that a {@code false} result in no way gaurantees that a later call
82     * to, e.g., {@link #setFuture} will succeed, since another thread could
83     * make the call in between.  This is somewhat analogous to {@link #isDone},
84     * but since setting and completing are not the same event, it is useful to
85     * have this method broken out.
86     */
87    public boolean isSet() {
88      return nested.isDone();
89    }
90  
91    private static final class NestedFuture<V> extends AbstractFuture<ListenableFuture<? extends V>> {
92      boolean setFuture(ListenableFuture<? extends V> value) {
93        boolean result = set(value);
94        if (isCancelled()) {
95          value.cancel(wasInterrupted());
96        }
97        return result;
98      }
99    }
100 }